//! - 对象：用户自定义类型，支持属性、方法、继承

use crate::interpreter::value::Value;
use crate::type_system::function_object_types::FunctionType;
use std::cell::RefCell;
use std::collections::HashMap;
use std::rc::Rc;

/// 用户自定义对象类型(物)的实现
#[derive(Clone)]
pub struct ObjectType {
    /// 对象名称
    pub name: String,
    /// 对象属性（字段）
    pub fields: HashMap<String, Value>,
    /// 对象方法
    pub methods: HashMap<String, Rc<FunctionType>>,
    /// 父类（支持继承）
    pub parent: Option<Rc<RefCell<ObjectType>>>,
    /// 类型注解
    pub type_annotations: HashMap<String, String>,
}

impl ObjectType {
    /// 创建新的对象类型
    pub fn new(name: String) -> Self {
        Self {
            name,
            fields: HashMap::new(),
            methods: HashMap::new(),
            parent: None,
            type_annotations: HashMap::new(),
        }
    }

    /// 设置字段值
    pub fn set_field(&mut self, field_name: String, value: Value) -> Result<(), String> {
        // 如果存在类型注解，验证类型
        if let Some(expected_type) = self.type_annotations.get(&field_name) {
            if !self.is_type_compatible(expected_type, &value) {
                return Err(format!(
                    "字段 '{}' 类型不匹配：期望 '{}', 实际为 '{}'",
                    field_name,
                    expected_type,
                    value.get_type_name()
                ));
            }
        }

        self.fields.insert(field_name, value);
        Ok(())
    }

    /// 获取字段值
    pub fn get_field(&self, field_name: &str) -> Option<Value> {
        // 先在当前对象中查找
        if let Some(value) = self.fields.get(field_name) {
            return Some(value.clone());
        }

        // 如果在父类中查找
        if let Some(parent) = &self.parent {
            return parent.borrow().get_field(field_name);
        }

        None
    }

    /// 设置方法
    pub fn set_method(&mut self, method_name: String, method: FunctionType) {
        self.methods.insert(method_name, Rc::new(method));
    }

    /// 获取方法
    pub fn get_method(&self, method_name: &str) -> Option<Rc<FunctionType>> {
        // 先在当前对象中查找
        if let Some(method) = self.methods.get(method_name) {
            return Some(method.clone());
        }

        // 如果在父类中查找
        if let Some(parent) = &self.parent {
            return parent.borrow().get_method(method_name);
        }

        None
    }

    /// 设置父类（继承）
    pub fn set_parent(&mut self, parent: Rc<RefCell<ObjectType>>) {
        self.parent = Some(parent);
    }

    /// 添加类型注解
    pub fn add_type_annotation(&mut self, field_name: String, type_name: String) {
        self.type_annotations.insert(field_name, type_name);
    }

    /// 类型兼容性检查
    fn is_type_compatible(&self, expected_type: &str, value: &Value) -> bool {
        let actual_type = value.get_type_name();

        // 精确匹配
        if expected_type == actual_type {
            return true;
        }

        // 数字类型兼容性
        if expected_type == "数" && (actual_type == "数" || actual_type == "整数") {
            return true;
        }

        // 字符串类型兼容性
        if expected_type == "文" && actual_type == "文" {
            return true;
        }

        // 布尔类型兼容性
        if expected_type == "真伪" && actual_type == "真伪" {
            return true;
        }

        // 列表类型兼容性
        if expected_type == "集" && actual_type == "集" {
            return true;
        }

        // 字典类型兼容性
        if expected_type == "辞" && actual_type == "辞" {
            return true;
        }

        // 集合类型兼容性
        if expected_type == "汇" && actual_type == "汇" {
            return true;
        }

        // 元组类型兼容性
        if expected_type == "组" && actual_type == "组" {
            return true;
        }

        // 函数类型兼容性
        if expected_type == "函" && actual_type == "函" {
            return true;
        }

        // 对象类型兼容性
        if expected_type == "物" && actual_type == "物" {
            return true;
        }

        // 空值兼容性
        if expected_type == "无" && actual_type == "无" {
            return true;
        }

        false
    }

    /// 获取所有字段名称（包括继承的）
    pub fn get_all_field_names(&self) -> Vec<String> {
        let mut names: Vec<String> = self.fields.keys().cloned().collect();

        if let Some(parent) = &self.parent {
            let parent_names = parent.borrow().get_all_field_names();
            names.extend(parent_names);
        }

        names.sort();
        names.dedup();
        names
    }

    /// 获取所有方法名称（包括继承的）
    pub fn get_all_method_names(&self) -> Vec<String> {
        let mut names: Vec<String> = self.methods.keys().cloned().collect();

        if let Some(parent) = &self.parent {
            let parent_names = parent.borrow().get_all_method_names();
            names.extend(parent_names);
        }

        names.sort();
        names.dedup();
        names
    }

    /// 转换为字符串表示
    pub fn to_string(&self) -> String {
        format!("<对象: {}>", self.name)
    }
}

#[cfg(test)]
mod tests {
    use super::ObjectType;

    #[test]
    fn test_object_type_creation() {
        let obj = ObjectType::new("测试对象".to_string());

        assert_eq!(obj.name, "测试对象");
        assert!(obj.fields.is_empty());
        assert!(obj.methods.is_empty());
        assert!(obj.parent.is_none());
    }
}
